package com.ks.winterwarmimage.database;

import android.annotation.SuppressLint;
import android.content.ContentValues;
import android.content.Context;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.text.TextUtils;
import android.util.Log;

import androidx.annotation.StringDef;

import com.ks.winterwarmimage.esptouch.EspTouchManage;
import com.ks.winterwarmimage.utils.Constants;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

public class DatabaseManager {
    private static final String TAG= "DatabaseManager";
    public static SQLiteDatabase database;
    private static Context context;
    /**
     * 创建数据库
     * @param context
     */
    public static void createDatabase(Context context){
        DatabaseManager.context=context;
        DatabaseManager.database = context.openOrCreateDatabase(Constants.DB_NAME, Context.MODE_PRIVATE, null);
    }
    public static int getDatabaseVersion(){
        return database.getVersion();
    }
    public static  SQLiteDatabase getDatabase(){
        return database;
    }
    /**
     * 在现有表单中删除字段
     * @param tableName 需要删除字段的表单
     * @param columnName 需要删除的字段
     * @return
     */
    public static boolean deleteField( String tableName, String columnName){
        if(database!=null) {
            try {
                Cursor cursor = database.rawQuery("SELECT * FROM " + tableName, null);
                if(cursor!=null){
                    cursor.getColumnNames();
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < cursor.getColumnNames().length; i++) {
                        if(!cursor.getColumnNames()[i].toLowerCase().equals(columnName.toLowerCase())) {
                            if (sb.length() > 0) {
                                sb.append(",");
                            }
                            sb.append(cursor.getColumnNames()[i]);
                        }
                    }
                    Log.e("deleteField","字段列表="+sb.toString());
                    cursor.close();  //关闭表单
                    String SQL ="CREATE TABLE temp1 As SELECT "+ sb.toString() +" FROM "+tableName+" WHERE 1=1";//复制一个与指定表单相同的临时表单（除需要删除的字段）
                    database.execSQL(SQL);
                    SQL ="DROP TABLE "+tableName;  //删除旧表单
                    database.execSQL(SQL);
                    SQL ="ALTER TABLE temp1 RENAME TO "+tableName;  //重命名临时表单为旧表单名称
                    database.execSQL(SQL);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                Log.e("deleteField",e.getMessage());
            }
        }
        return false;
    }
    /**
     * 判断指定表单是否存在
     * @param tableName 表单名称
     * @return true 找到表单，false 没有找到指定表单equals
     */
    public static boolean existsTable( String tableName) {
        boolean result = false;
        try {
            String sql = "SELECT count(*) As c FROM sqlite_master WHERE type ='table' And name ='"+ tableName.trim()+"' ";
            Cursor cursor =database.rawQuery(sql,null);
            if(cursor.moveToNext()){
                int count = cursor.getInt(0);
                if(count>0){
                    result = true;
                }
            }
            cursor.close();
        } catch (Exception e) {
            Log.e(TAG, "isExistTable::"+e.getMessage());
        }
        return result;
    }
    /**
     * 检查表中某列是否存在
     * @param tableName 需要检查的表单名称
     * @param columnName 需要检查的字段名称
     * @return
     */
    public static boolean existsColumn( String tableName, String columnName){
        boolean result = false ;
        Cursor cursor = null ;
        try{
            String sql="SELECT * FROM sqlite_master WHERE name=? And sql LIKE ?";
            cursor = database.rawQuery( sql, new String[]{tableName , "%" + columnName + "%"} );
            result = null != cursor && cursor.moveToFirst() ;
        }catch (Exception e){
            Log.e("","existsColumn..." + e.getMessage()) ;
        }finally{
            if(null != cursor && !cursor.isClosed()){
                cursor.close() ;
            }
        }
        return result;
    }
    /**
     * 在表单中添加字段
     * @param tableName 需要插入字段的表单
     * @param columnName 要插入的列名称
     * @param datatype 列数据类型,请使用字段类型字符串,使用{@link Fields.FieldType}里面的参数，否则会报错。
     *                 正确参数写法如：<br />{@link Fields.FieldType#FIELD_TYPE_TINYINT}
     * @param defaultVal 默认值
     * @return
     */
    public static boolean addField( String tableName, String columnName,@Fields.FieldType String datatype, Object defaultVal){
        if(database!=null) {
            String valStr;
            if ((defaultVal instanceof String) && (defaultVal instanceof Date)) {
                valStr="'"+ defaultVal+"'";
            } else {
                valStr= String.valueOf(defaultVal) ;
            }
            String SQL = "ALTER TABLE " + tableName + " ADD " + columnName+" "+ datatype  + (defaultVal!=null?" default " + valStr:"");
            try {
                database.execSQL(SQL);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                Log.e("addField",e.getMessage());
            }
        }
        return false;
    }
    /**
     * 查询表单数据
     * @param tableName 表单名称
     * @param whereClause 查询时要应用的可选WHERE子句。传递null将查询所有行："字段1=? AND 字段=?"。
     * @param whereArgs 可以包括?将被whereArgs中的值替换。这些值将被绑定为字符串。
     * @return
     */
    public static Cursor rawQuery(String tableName, String whereClause, String[] whereArgs){
        Cursor cursor = null;
        whereClause= (whereClause!=null && whereClause.length()>0)?(" WHERE " + whereClause):"";
        try {
            String SQL="SELECT * FROM "+tableName + whereClause;
            Log.e(TAG,"rawQuery::"+SQL);
            cursor = database.rawQuery(SQL, whereArgs);
        } catch (Exception e) {
            Log.e(TAG , "rawQuery::"+e.getMessage());
        }
        return cursor;
    }
    /**
     * 组表和子表连接查询
     * @param tableLeft 左表单名称
     * @param tableRight 右表单名称
     * @param whereClause 查询时要应用的可选WHERE子句。传递null将查询所有行："字段1=? AND 字段=?"。
     * @param whereArgs 可以包括?将被whereArgs中的值替换。这些值将被绑定为字符串。
     * @return
     */
    public static Cursor rawJoinQuery(String tableLeft, String tableRight, String whereClause, String[] whereArgs){
        Cursor cursor = null;
        whereClause= (whereClause!=null && whereClause.length()>0)?(" WHERE " + whereClause):"";
        try {
            String SQL = "SELECT g.groupId, g.groupName,g.groupPassword, l.lampId, l.lampName, l.lampType FROM " +
                    tableLeft + " g LEFT JOIN " + tableRight + " l ON g.groupId = l.groupId" +whereClause ;
            Log.e(TAG,"rawQuery::"+SQL);
            cursor = database.rawQuery(SQL, whereArgs);
        } catch (Exception e) {
            Log.e(TAG , "rawQuery::"+e.getMessage());
        }
        return cursor;
    }
    public static Cursor rawQuery( String sql, String[] whereArgs){
        Cursor cursor = null;
        try {
            Log.e(TAG,"rawQuery::"+sql);
            cursor = database.rawQuery(sql, whereArgs);
        } catch (Exception e) {
            Log.e(TAG , "rawQuery::"+e.getMessage());
        }
        return cursor;
    }
    /**
     * 查询表单数据条数
     * @param tableName 需要查询的表单名称
     * @param whereClause 查询时要应用的可选WHERE子句。传递null将查询所有行："字段1=? AND 字段=?"。
     * @param whereArgs 可以包括?将被whereArgs中的值替换。这些值将被绑定为字符串。
     * @return
     */
    public static int rawQueryDataCount(String tableName,String whereClause, String[] whereArgs){
        int count=0;
        whereClause= (whereClause!=null && whereClause.length()>0)?(" WHERE " + whereClause):"";
        // 编写SQL语句来计算表中的记录数
        String SQL = "SELECT COUNT(*) FROM "+tableName+whereClause;
        try {
            Cursor cursor = database.rawQuery(SQL, whereArgs);
            if(cursor!=null){
                // 移动游标到第一条记录
                if (cursor.moveToFirst()) {
                    // 获取计数结果，索引0表示第一列（即COUNT(*)的结果）
                    count = cursor.getInt(0);
                    // 输出结果或进行其他操作
                    Log.d("Database Count", "Number of rows: " + count);
                }
                cursor.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return count;
    }
    /**
     * 查询表单数据条数
     * @param tableName 需要查询的表单名称
     * @return
     */
    public static int rawQueryDataCount(String tableName){
        return rawQueryDataCount(tableName,null,null);
    }
    /**
     * 插入数据，冲突算法
     * @param tableName
     * @param values
     * @param conflictAlgorithm
     * @return
     */
    public static long insertWithOnConflict(String tableName, ContentValues values, int conflictAlgorithm){
        // return database.insertWithOnConflict(tableName, null, values, conflictAlgorithm);
        long result = -1;
        if(values!=null){
            database.beginTransaction(); //以独占模式开始事务。
            try {
                String macId = values.getAsString(Constants.KEY_MAC_ID);
                if(macId != null && !macId.isEmpty()) {
                    Cursor cursor = database.query(tableName, new String[]{Constants.KEY_MAC_ID}, Constants.KEY_MAC_ID + "=?", new String[]{macId}, null, null, null);
                    //(不区分大小写)
                    //Cursor cursor = database.query(tableName, new String[]{Constants.KEY_MAC_ID}, Constants.KEY_MAC_ID + "=?", new String[]{macId}, null, null, "LOWER(" + Constants.KEY_MAC_ID + ")=LOWER(?)");
                    if(cursor != null && cursor.getCount() > 0) {
                        // 存在则更新
                        result= database.update(tableName, values, Constants.KEY_MAC_ID + "=?", new String[]{macId});
                    } else {
                        // 不存在则插入
                        //database.insertWithOnConflict(tableName, null, values, conflictAlgorithm);
                        result= database.insert(tableName, null, values);
                    }
                }else{
                    result= database.insertWithOnConflict(tableName, null, values, conflictAlgorithm);
                }
                database.setTransactionSuccessful(); //将当前事务标记为成功。
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                database.endTransaction(); //结束事务。
            }
        }
        return result;
    }
    /**
     * 批量插入数据。这里的批量插入深度通常是常规插入方式的40倍左右
     * @param tableName 表单名称
     * @param valuesList 要插入的字段集合列表
     * @return 成功返回影响的行数（正确插入的行数）
     */
    public static int insertWithOnConflict(String tableName, List<ContentValues> valuesList, int conflictAlgorithm){
        int count=0;
        if(valuesList!=null) {
            database.beginTransaction(); //以独占模式开始事务。
            try {
                for(int i=0;i<valuesList.size();i++){
                    ContentValues values = valuesList.get(i);
                    String macId = values.getAsString(Constants.KEY_MAC_ID);
                    if(macId != null && !macId.isEmpty()) {
                        // 先查询是否存在相同KEY_MAC_ID的记录(不区分大小写)
                        Cursor cursor = database.query(tableName, new String[]{Constants.KEY_MAC_ID}, Constants.KEY_MAC_ID + "=?", new String[]{macId}, null, null, null);
                        if(cursor != null && cursor.getCount() > 0) {
                            // 存在则更新
                            database.update(tableName, values, Constants.KEY_MAC_ID + "=?", new String[]{macId});
                        } else {
                            // 不存在则插入
                            //database.insertWithOnConflict(tableName, null, values, conflictAlgorithm);
                            database.insert(tableName, null, values);
                        }
                        count++;
                        if(cursor != null) {
                            cursor.close();
                        }
                    } else {
                        // 没有KEY_MAC_ID则直接插入
                        database.insertWithOnConflict(tableName, null, values, conflictAlgorithm);
                        count++;
                    }
                }
                database.setTransactionSuccessful(); //将当前事务标记为成功。
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                database.endTransaction(); //结束事务。
            }
        }
        return count;
    }

    /**
     * 移除设备数据
     * @param id mac id
     * @return 0 移除失败
     */
    public static boolean removeDevice(String id){
        try {
            if(id!=null && id.length()>0) {
                return database.delete(Constants.TABLE_DEV, Constants.KEY_MAC_ID + "=?", new String[]{id})>0;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
    /**
     *更新账户
     * @param accountID 账户ID（8字符）
     */
    public static void  updateAccount(String accountID){
        //只对8位有效字符处理
        if(accountID!=null && accountID.getBytes(EspTouchManage.GB2312).length==8) {
            SharedPreferences sharedPreferences = context.getSharedPreferences(Constants.TABLE_ACCOUNT, Context.MODE_PRIVATE);
            String listString = sharedPreferences.getString(Constants.KEY_ACCOUNT_IDS, null);
            List<String> accounts = null;
            if (listString != null)
                accounts = new ArrayList<>(Arrays.asList(listString.split(",")));
            boolean isExist = false;   //账户是否已存在
            if (accounts != null) {
                for (String account : accounts) {
                    if (account.equalsIgnoreCase(accountID)) {
                        isExist = true;
                        break;
                    }
                }
            } else {
                accounts = new ArrayList<>();
            }
            if (!isExist) {
                accounts.add(accountID);
                //将List转换为字符串
                listString = TextUtils.join(",", accounts);
                //将字符串写入SharedPreferences
                sharedPreferences.edit().putString(Constants.KEY_ACCOUNT_IDS, listString).apply();
            }
        }
    }
    /**
     * 获取本地已注册的账户列表
     * @return
     */
    public static List<String> getAccountList(){
        SharedPreferences sharedPreferences= context.getSharedPreferences(Constants.TABLE_ACCOUNT, Context.MODE_PRIVATE);
        String listString= sharedPreferences.getString(Constants.KEY_ACCOUNT_IDS,null);
        if(listString!=null) {
            return new ArrayList<>(Arrays.asList(listString.split(",")));
        }
        return null;
    }

    /**
     * 获取账户数量
     * @return
     */
    public static int getAccountCount(){
        List<String> accounts=getAccountList();
        return accounts!=null?accounts.size():0;
    }
    /**
     * 获取当前账户
     * @return
     */
    public static String getCurrentAccount(){
        SharedPreferences sharedPreferences= context.getSharedPreferences(Constants.TABLE_ACCOUNT, Context.MODE_PRIVATE);
        String listString= sharedPreferences.getString(Constants.KEY_ACCOUNT_IDS,null);
        if(listString!=null) {
            int position=sharedPreferences.getInt(Constants.KEY_POSITION,0);
            List<String> accounts = new ArrayList<>(Arrays.asList(listString.split(",")));
            if(position>accounts.size()){
                return null;
            }else{
                return accounts.get(position);
            }
        }
        return null;
    }
    /**
     * 移除指定账户
     * @return
     */
    public static void removeAccount(String accountID){
        SharedPreferences sharedPreferences= context.getSharedPreferences(Constants.TABLE_ACCOUNT, Context.MODE_PRIVATE);
        String listString= sharedPreferences.getString(Constants.KEY_ACCOUNT_IDS,null);
        if(listString!=null) {
            List<String> accounts = new ArrayList<>(Arrays.asList(listString.split(",")));
            if (accounts != null) {
                for (String account : accounts) {
                    if (account.equalsIgnoreCase(accountID)) {
                        accounts.remove(account);
                        //将List转换为字符串
                        listString = TextUtils.join(",", accounts);
                        //将字符串写入SharedPreferences
                        sharedPreferences.edit().putString(Constants.KEY_ACCOUNT_IDS, listString).apply();
                        return;
                    }
                }
            }
        }
    }

    /**
     * 更新当前账户位置
     * @param position 0~n
     */
    public static void updateCurrentAccountPosition(int position){
        SharedPreferences sharedPreferences= context.getSharedPreferences(Constants.TABLE_ACCOUNT, Context.MODE_PRIVATE);
        sharedPreferences.edit().putInt(Constants.KEY_POSITION,position).apply();
    }
    /**
     * 获取当前账户位置
     * @return 0~n
     */
    public static int getCurrentAccountPosition(){
        SharedPreferences sharedPreferences= context.getSharedPreferences(Constants.TABLE_ACCOUNT, Context.MODE_PRIVATE);
        return sharedPreferences.getInt(Constants.KEY_POSITION,0);
    }

    /**
     * 数据库字段管理
     */
    public static class Fields{
        /**字段名称*/
        private String FieldName;
        /**字段类型*/
        private @FieldType
        String fieldType;
        /**字符缓冲大小或十进制数据小数点后保留位数*/
        private int Size;
        /**十进制数精度*/
        private int Precision=10;
        @StringDef({
                FieldType.FIELD_TYPE_INTEGER, FieldType.FIELD_TYPE_INT, FieldType.FIELD_TYPE_TINYINT, FieldType.FIELD_TYPE_SMALLINT,
                FieldType.FIELD_TYPE_MEDIUMINT, FieldType.FIELD_TYPE_BIGINT, FieldType.FIELD_TYPE_UNSIGNED_BIG_INT, FieldType.FIELD_TYPE_INT2,
                FieldType.FIELD_TYPE_INT8, FieldType.FIELD_TYPE_REAL, FieldType.FIELD_TYPE_DOUBLE, FieldType.FIELD_TYPE_DOUBLE_PRECISION,
                FieldType.FIELD_TYPE_FLOAT, FieldType.FIELD_TYPE_CHARACTER, FieldType.FIELD_TYPE_VARCHAR, FieldType.FIELD_TYPE_VARYING_CHARACTER,
                FieldType.FIELD_TYPE_CHAR,FieldType.FIELD_TYPE_NCHAR, FieldType.FIELD_TYPE_NATIVE_CHARACTER, FieldType.FIELD_TYPE_NVARCHAR,
                FieldType.FIELD_TYPE_TEXT,FieldType.FIELD_TYPE_CLOB, FieldType.FIELD_TYPE_BLOB, FieldType.FIELD_TYPE_NUMERIC,
                FieldType.FIELD_TYPE_DECIMAL,FieldType.FIELD_TYPE_BOOLEAN, FieldType.FIELD_TYPE_DATE, FieldType.FIELD_TYPE_DATETIME
        })
        /**
         * 数据字段类型注解接口，替代类型枚举
         */
        @Retention(RetentionPolicy.SOURCE)
        public @interface FieldType{
            /**一个带符号的整数，根据值的大小存储在 1、2、3、4、6 或 8 字节中*/
            String FIELD_TYPE_INTEGER= "INTEGER";
            /**一个正常大小整数。有符号的范围是-2^31 (-2,147,483,648) 到 2^31 - 1 (2,147,483,647) 的整型数据（所有数字），无符号的范围是0到4294967295。一位大小为 4 个字节。*/
            String FIELD_TYPE_INT= "INT";
            /**有符号的范围是-128 - 127，无符号的范围是 从 0 到 255 的整型数据。一位大小为 1 字节。*/
            String FIELD_TYPE_TINYINT= "TINYINT";
            /**一个小整数。有符号的范围是-2^15 (-32,768) 到 2^15 - 1 (32,767) 的整型数据，无符号的范围是0到65535。一位大小为 2 个字节。MySQL提供的功能已经绰绰有余，而且由于MySQL是开放源码软件，因此可以大大降低总体拥有成本。*/
            String FIELD_TYPE_SMALLINT= "SMALLINT";
            /**一个中等大小整数，有符号的范围是-8388608到8388607，无符号的范围是0到16777215。 一位大小为3个字节。*/
            String FIELD_TYPE_MEDIUMINT= "MEDIUMINT";
            /**从 -2^63 (-9223372036854775808) 到 2^63-1 (9223372036854775807) 的整型数据（所有数字），无符号的范围是0到8446744073709551615。一位为 8 个字节。*/
            String FIELD_TYPE_BIGINT= "BIGINT";
            /**无符号大整数*/
            String FIELD_TYPE_UNSIGNED_BIG_INT= "UNSIGNED BIG INT";
            /**2字节 有符号整型, 符号占1位，余下15位2进制位表示数值 。最大数正数是 0x7fff*/
            String FIELD_TYPE_INT2= "INT2";
            /**8字节 有符号整型 符号占1位，余下63位2进制位表示数值 。最大数正数是 0x7fffffffffffffff*/
            String FIELD_TYPE_INT8= "INT8";
            /**一个浮点值，存储为 8 字节的 IEEE 浮点数字*/
            String FIELD_TYPE_REAL= "REAL";
            /**双精度浮点类型*/
            String FIELD_TYPE_DOUBLE= "DOUBLE";
            /**双双精度浮点类型*/
            String FIELD_TYPE_DOUBLE_PRECISION= "DOUBLE PRECISION";
            /**单精度浮点类型*/
            String FIELD_TYPE_FLOAT= "FLOAT";
            /**n 长度的字串，n不能超过 254。 如：CHARACTER(20)*/
            String FIELD_TYPE_CHARACTER= "CHARACTER";
            /**n长度的可变长字符型，不超过4000。如：VARCHAR(50)*/
            String FIELD_TYPE_VARCHAR= "VARCHAR";
            /**n长度的可变长字符型。如：VARYING CHARACTER(255)*/
            String FIELD_TYPE_VARYING_CHARACTER= "VARYING CHARACTER";
            /**固定长度字符串,需指定长度，如：CHAR(55)*/
            String FIELD_TYPE_CHAR="CHAR";
            /**固定长度字符串，需指定长度，如：NCHAR(55)*/
            String FIELD_TYPE_NCHAR= "NCHAR";
            /**固定长度字符串，需指定长度，如：NATIVE CHARACTER(55)*/
            String FIELD_TYPE_NATIVE_CHARACTER= "NATIVE CHARACTER";
            /**可变长度文本，需指定长度，如：NVARCHAR(100)*/
            String FIELD_TYPE_NVARCHAR= "NVARCHAR";
            /**一个文本字符串，使用数据库编码（UTF-8、UTF-16BE 或 UTF-16LE）存储*/
            String FIELD_TYPE_TEXT= "TEXT";
            /**表示字符大对象，存放大量基于字符的数据。*/
            String FIELD_TYPE_CLOB= "CLOB";
            /**数据不做任何转换，以输入形式存储，二进制大对象，这种数据类型通过用来保存图片，图象，视频等。*/
            String FIELD_TYPE_BLOB= "BLOB";
            /**数字格式*/
            String FIELD_TYPE_NUMERIC="NUMERIC";
            /**p 精确值和 s 大小的十进位整数，精确值p是指全部有几个数(digits)大小值，s是指小数点後有几位数。如果没有特别指定，则系统会设为 p=5; s=0 。 如"DECIMAL(10,5)"*/
            String FIELD_TYPE_DECIMAL="DECIMAL";
            /**布尔型*/
            String FIELD_TYPE_BOOLEAN="BOOLEAN";
            /**日期型*/
            String FIELD_TYPE_DATE="DATE";
            /**日期时间型*/
            String FIELD_TYPE_DATETIME="DATETIME";
        }

        /**构建函数*/
        public Fields(){
            super();
        }
        /**
         * 构建函数
         * @param FieldName 字段名称
         * @param FieldType 字段类型
         */
        public Fields(String FieldName,@FieldType String FieldType){
            this.FieldName=FieldName;
            this.fieldType=FieldType;
        }
        /**获取字段名称*/
        public String getFieldName(){
            return FieldName;
        }
        /**
         * 设置字段名称
         * @param FieldName 字段名称
         */
        public void setFieldName(String FieldName){
            this.FieldName=  FieldName;
        }
        /**获取字段类型*/
        @FieldType
        public String getFieldType(){
            return fieldType;
        }
        /**
         * 设置字段类型
         * @param fieldType 字段类型字符串,使用{@link FieldType}里面的参数，否则会报错。
         *                  正确参数写法如：{@link FieldType#FIELD_TYPE_TINYINT}
         */
        public void setFieldType( @FieldType String fieldType){
            this.fieldType=  fieldType;
        }
        /**获取字符型缓存大小或十进制数小数保留位数。
         * 只对FIELD_TYPE_CHARACTER,FIELD_TYPE_VARCHAR,FIELD_TYPE_VARYING_CHARACTER,FIELD_TYPE_NCHAR,FIELD_TYPE_NATIVE_CHARACTER,FIELD_TYPE_NVARCHAR,FIELD_TYPE_DECIMAL类型数据有效。
         * */
        public int getSize() {
            return Size;
        }
        /**
         * 设置字符型缓存大小或十进制数小数保留位数。
         * 只对FIELD_TYPE_CHARACTER,FIELD_TYPE_VARCHAR,FIELD_TYPE_VARYING_CHARACTER,FIELD_TYPE_NCHAR,FIELD_TYPE_NATIVE_CHARACTER,FIELD_TYPE_NVARCHAR,FIELD_TYPE_DECIMAL类型数据有效。
         * @param size 缓存大小或小数位位数
         */
        public void setSize(int size) {
            Size = size;
        }
        /**
         * 获取十进制数精度。只有FIELD_TYPE_DECIMAL类型数据有效
         * @return
         */
        public int getPrecision() {
            return Precision;
        }
        /**
         * 设置十进制数精度。只有FIELD_TYPE_DECIMAL类型数据有效
         * @param precision 精度。
         */
        public void setPrecision(int precision) {
            Precision = precision;
        }
        /**
         * 设置十进制数精度及小数位
         * @param precision
         * @param size
         */
        public void setDecimalPrecision(int precision,int size){
            this.Precision = precision;
            this.Size=size;
        }
        @SuppressLint("WrongConstant")
        @Override
        public String toString() {
            String tempType=fieldType.toUpperCase();//将字符串转为大写
            if(tempType.equals(FieldType.FIELD_TYPE_CHARACTER)) {
                fieldType+=(this.Size==0)?"(20)":"("+Size+")";
            }else if(tempType.equals(FieldType.FIELD_TYPE_VARCHAR)){
                fieldType+=(this.Size==0)?"(255)":"("+Size+")";
            }else if(tempType.equals(FieldType.FIELD_TYPE_VARYING_CHARACTER)){
                fieldType+=(this.Size==0)?"(255)":"("+Size+")";
            }else if(tempType.equals(FieldType.FIELD_TYPE_NCHAR)){
                fieldType+=(this.Size==0)?"(50)":"("+Size+")";
            }else if(tempType.equals(FieldType.FIELD_TYPE_NATIVE_CHARACTER)){
                fieldType+=(this.Size==0)?"(70)":"("+Size+")";
            }else if(tempType.equals(FieldType.FIELD_TYPE_NVARCHAR)){
                fieldType+=(this.Size==0)?"(100)":"("+Size+")";
            }else if(tempType.equals(FieldType.FIELD_TYPE_DECIMAL)){
                this.Precision=(this.Precision==0)?5:this.Precision;
                fieldType+="("+this.Precision+","+this.Size+")";
            }
            return FieldName+" "+fieldType;
        }
    }
}
